/*
  ES6模块化
    引入 import
      直接引入
        import xxx from './xxx'
        引入的是什么？引入的是模块暴露default属性的值
          import { default } from './xxx'
          const xxx = default

      解构引入
        import { a, b, c } from './xxx'
      全部引入
        import * as xxx from './xxx'

    暴露 export
      默认暴露 export default xxx
        暴露的数据结构：{ default: xxx }
        可以使用直接引入或全部引入，不能使用解构引入，
        一般都使用直接引入
      统一暴露
        只能使用解构引入或全部引入, 不能使用直接引入
      分别暴露
        只能使用解构引入或全部引入, 不能使用直接引入

        如何引入分别暴露的内容来使用？
          import m1 from './m1' --> undefined
            为什么是undefined？直接引入引入的是default的值，而分别暴露没有暴露default。所以是undefined
          import { a, b, c, d } from './m1' --> 111 222 333 444
            提取m1模块的a、b、c、d内容
          import * as m1 from './m1' --> { a: 111, b: 222, c: 333, d: 444 }
            引入m1模块的所有内容，并命名为m1
*/
// import m5, { c, d } from './m5'
import { a, b, c, d } from './m5'
console.log(a, b, c, d)
// import * as m5 from './m5'
// console.log(m5.default.a, m5.default.b, m5.c, m5.d)

// import m4 from './m4'
// console.log(m4) // 就是默认暴露default的值
// import { a, b, c } from './m4'
// console.log(a, b, c)
// import * as m4 from './m4'
// console.log(m4.default.a) // { default: { a, b, c } }

// import m3 from './m3'
// console.log(m3)
// import { a, b, c } from './m3'
// console.log(a, b, c)
// import * as m3 from './m3'
// console.log(m3)

// 情况1: 直接引入是undefined
// import m1 from './m1'

// 情况2: 解构引入没有问题，但是可能导致命名污染
// import { a, b, c, d } from './m1'
// import { a, b } from './m2'

// 情况3: 全部引入并重命名
// import * as m1 from './m1'
// import * as m2 from './m2'

// console.log('m1', m1.a, m1.b, m1.c, m1.d)
